const Post = require('../models/post.model');
const User = require('../models/user.model');
const Comment = require('../models/comment.model');
const fs = require('fs');
const path = require('path');
const { validationResult } = require('express-validator');

// 创建帖子
async function createPost(req, res) {
  const errors = validationResult(req);
  if (!errors.isEmpty()) {
    if (req.files && req.files.images) {
      req.files.images.forEach(file => {
        fs.unlink(file.path, (err) => {
          if (err) console.error(`删除上传文件失败: ${file.path}`, err);
        });
      });
    }
    return res.status(400).json({ errors: errors.array() });
  }

  try {
    const { title, content, tags, isDraft, category } = req.body;
    const userId = req.user._id;
    const images = req.files && req.files.images ? req.files.images.map(file => `/uploads/posts/${file.filename}`) : [];

    // 处理 tags 字段
    let parsedTags = [];
    if (tags) {
      if (typeof tags === 'string') {
        try {
          parsedTags = JSON.parse(tags);
        } catch (e) {
          console.error('解析 tags 失败:', e);
          parsedTags = [];
        }
      } else if (Array.isArray(tags)) {
        parsedTags = tags;
      }
    }

    const post = new Post({
      title,
      content,
      user: userId,
      images,
      tags: parsedTags,
      isDraft: isDraft === 'true' || isDraft === true, // 处理布尔值
      category
    });

  
    if (!post.isDraft) {
      post.status = 'approved'; 
    }

    await post.save();

   

    res.status(201).json({ message: isDraft ? '草稿保存成功' : '帖子发布成功', post });

  } catch (error) {
    console.error('创建帖子失败:', error);
    // 同样，如果出错，删除已上传的文件
    if (req.files && req.files.images) {
      req.files.images.forEach(file => {
        fs.unlink(file.path, (err) => {
          if (err) console.error(`删除上传文件失败: ${file.path}`, err);
        });
      });
    }
    res.status(500).json({ error: '创建帖子失败' });
  }
}

// 获取帖子列表（例如社区首页）
async function getPosts(req, res) {
  try {
    const { page = 1, limit = 10, sort = 'latest', tag, search, startDate, endDate, category } = req.query;
    const skip = (page - 1) * limit;
    const sortBy = sort; // Map 'sort' to 'sortBy' for consistency with existing code
    const requestingUser = req.user; // 获取当前请求的用户信息

    let query = { isDraft: false };

    // 根据用户角色决定状态过滤
    if (requestingUser && requestingUser.role === 'admin') {
      // 管理员可以看到所有状态，除非明确指定了 status 过滤
      if (req.query.status) {
        query.status = req.query.status;
      }
    } else {
      // 普通用户只能看到 'approved' 状态的帖子
      query.status = 'approved';
    }

    if (tag) {
      query.tags = tag;
    }

    // 添加搜索条件
    if (search) {
      query.$or = [
        { title: { $regex: search, $options: 'i' } }, // 标题模糊搜索，不区分大小写
        { content: { $regex: search, $options: 'i' } } // 内容模糊搜索，不区分大小写
      ];
    }

    // 添加日期范围过滤
    if (startDate && endDate) {
      query.createdAt = {
        $gte: new Date(startDate), // 大于等于开始日期
        $lte: new Date(new Date(endDate).setDate(new Date(endDate).getDate() + 1)) // 小于等于结束日期（加一天确保包含结束日当天）
      };
    } else if (startDate) {
      query.createdAt = { $gte: new Date(startDate) };
    } else if (endDate) {
      query.createdAt = { $lte: new Date(new Date(endDate).setDate(new Date(endDate).getDate() + 1)) };
    }

    let sortOption = { createdAt: -1 }; // 默认按最新排序
    if (sortBy === 'popular') {
      // TODO: 实现更复杂的热度排序逻辑（点赞、评论、浏览量）
      sortOption = { views: -1, likes: -1 }; // 简单示例
    }

    const totalPosts = await Post.countDocuments(query);
    const posts = await Post.find(query)
      .sort(sortOption)
      .skip(skip)
      .limit(limit)
      .select('+images')
      .populate('user', 'username avatar')
      .populate('category', 'name') 
      .populate('comments'); 

    res.json({
      posts,
      currentPage: page,
      totalPages: Math.ceil(totalPosts / limit),
      totalPosts
    });

  } catch (error) {
    console.error('获取帖子列表失败:', error);
    res.status(500).json({ error: '获取帖子列表失败' });
  }
}

// 获取单个帖子详情
async function getPostDetails(req, res) {
  try {
    const postId = req.params.id;
    const post = await Post.findById(postId)
      .populate('user', 'username avatar bio subscribersCount')
      .populate({
        path: 'comments',
        populate: { path: 'user', select: 'username avatar' },
        options: { sort: { createdAt: -1 } }
      });

    if (!post || post.isDraft) {
      // 草稿只有作者能看，或者根据需求调整
      const isOwner = req.user && post && post.user._id.equals(req.user._id);
      if (!isOwner) {
          return res.status(404).json({ error: '帖子不存在或无权访问' });
      }
    }

    // 增加浏览次数
    if (!post.isDraft) { 
        await post.incrementViews();
    }

    res.json({ post });

  } catch (error) {
    console.error('获取帖子详情失败:', error);
    if (error.name === 'CastError') {
        return res.status(404).json({ error: '帖子 ID 格式无效' });
    }
    res.status(500).json({ error: '获取帖子详情失败' });
  }
}

// 更新帖子
async function updatePost(req, res) {
  const errors = validationResult(req);
  if (!errors.isEmpty()) {
    // 删除可能上传的新图片
    if (req.files && req.files.images) {
        req.files.images.forEach(file => fs.unlink(file.path, err => err && console.error(`删除上传文件失败: ${file.path}`, err)));
    }
    return res.status(400).json({ errors: errors.array() });
  }

  try {
    const postId = req.params.id;
    const userId = req.user._id;
    const { title, content, tags, isDraft, removedImages } = req.body;

    const post = await Post.findById(postId);

    if (!post) {
      return res.status(404).json({ error: '帖子不存在' });
    }

    // 检查权限
    if (!post.user.equals(userId)) {
      return res.status(403).json({ error: '没有权限修改该帖子' });
    }

    // 更新字段
    if (title !== undefined) post.title = title;
    if (content !== undefined) post.content = content;
    if (tags !== undefined) post.tags = tags || [];
    if (isDraft !== undefined) post.isDraft = isDraft === 'true' || isDraft === true;

    let currentImages = post.images || [];

    // 处理删除的图片
    const imagesToRemove = removedImages ? (Array.isArray(removedImages) ? removedImages : [removedImages]) : [];
    imagesToRemove.forEach(imageUrl => {
        const index = currentImages.indexOf(imageUrl);
        if (index > -1) {
            const imagePath = path.join(__dirname, '../../', imageUrl);
            fs.unlink(imagePath, err => err && console.error(`删除旧图片失败: ${imagePath}`, err));
            currentImages.splice(index, 1);
        }
    });

    // 处理新上传的图片
    const newImages = req.files && req.files.images ? req.files.images.map(file => `/uploads/posts/${file.filename}`) : [];
    currentImages = [...currentImages, ...newImages];

    // 检查图片总数限制 (例如最多9张)
    if (currentImages.length > 9) {
        // 删除新上传的文件并报错
        newImages.forEach(imageUrl => {
            const imagePath = path.join(__dirname, '../../', imageUrl);
            fs.unlink(imagePath, err => err && console.error(`删除超出限制的新图片失败: ${imagePath}`, err));
        });
        return res.status(400).json({ error: '图片总数不能超过9张' });
    }

    post.images = currentImages;

    await post.save();

    res.json({ message: '帖子更新成功', post });

  } catch (error) {
    console.error('更新帖子失败:', error);
    // 出错时删除新上传的文件
    if (req.files && req.files.images) {
        req.files.images.forEach(file => {
            const imagePath = path.join(__dirname, '../../', `/uploads/posts/${file.filename}`);
            fs.unlink(imagePath, err => err && console.error(`更新失败后删除新图片失败: ${imagePath}`, err));
        });
    }
    res.status(500).json({ error: '更新帖子失败' });
  }
}

// 删除帖子
async function deletePost(req, res) {
  try {
    const postId = req.params.id;
    const userId = req.user._id;

    const post = await Post.findById(postId);

    if (!post) {
      return res.status(404).json({ error: '帖子不存在' });
    }

    // 检查权限 (作者或管理员)
    const isAdmin = req.user.role === 'admin';
    if (!post.user.equals(userId) && !isAdmin) {
      return res.status(403).json({ error: '没有权限删除该帖子' });
    }

    // 删除帖子关联的图片文件
    if (post.images && post.images.length > 0) {
      post.images.forEach(imageUrl => {
        const imagePath = path.join(__dirname, '../../', imageUrl);
        fs.unlink(imagePath, (err) => {
          if (err) console.error(`删除帖子图片失败: ${imagePath}`, err);
        });
      });
    }

    // 删除帖子关联的评论 (可选，或者保留评论但标记帖子已删除)
    await Comment.deleteMany({ postId: postId });

    // 删除帖子
    await Post.findByIdAndDelete(postId);

    // TODO: 从用户点赞列表等地方移除引用

    res.json({ message: '帖子删除成功' });

  } catch (error) {
    console.error('删除帖子失败:', error);
    res.status(500).json({ error: '删除帖子失败' });
  }
}

// 点赞/取消点赞帖子
async function likePost(req, res) {
  try {
    const postId = req.params.id;
    const userId = req.user._id;

    const post = await Post.findById(postId);
    const user = await User.findById(userId);

    if (!post) {
      return res.status(404).json({ error: '帖子不存在' });
    }
    if (post.isDraft) {
        return res.status(403).json({ error: '不能对草稿进行操作' });
    }

    const userIndexInPostLikes = post.likes.indexOf(userId);

    let liked = false;
    if (userIndexInPostLikes === -1) {
      // 点赞
      post.likes.push(userId);
      liked = true;
    } else {
      // 取消点赞
      post.likes.splice(userIndexInPostLikes, 1);
    }

    // await user.save();
    await post.save();

    res.json({ liked, likesCount: post.likes.length });

  } catch (error) {
    console.error('点赞/取消点赞帖子失败:', error);
    res.status(500).json({ error: '操作失败' });
  }
}

// 获取用户对帖子的交互状态
async function getPostInteractionStatus(req, res) {
    try {
        const postId = req.params.id;
        const userId = req.user._id;

        const user = await User.findById(userId);
        if (!user) {
            return res.status(404).json({ error: '用户不存在' });
        }

        const post = await Post.findById(postId);
        if (!post) {
            return res.status(404).json({ error: '帖子不存在' });
        }

        const isLiked = post.likes.includes(userId);
        res.json({
            isLiked,
          
        });

    } catch (error) {
        console.error('获取帖子交互状态失败:', error);
        res.status(500).json({ error: '获取状态失败' });
    }
}

// 获取用户发布的帖子 (包括草稿)
async function getUserPosts(req, res) {
    try {
        const targetUserId = req.params.userId;
        const currentUserId = req.user ? req.user._id : null;
        const page = parseInt(req.query.page) || 1;
        const limit = parseInt(req.query.limit) || 10;
        const skip = (page - 1) * limit;
        const type = req.query.type || 'published'; // published, drafts

        let query = { user: targetUserId };

        // 只有用户自己能看自己的草稿
        if (type === 'drafts') {
            if (!currentUserId || !currentUserId.equals(targetUserId)) {
                return res.status(403).json({ error: '无权访问草稿' });
            }
            query.isDraft = true;
        } else {
            query.isDraft = false;
        }

        const totalPosts = await Post.countDocuments(query);
        const posts = await Post.find(query)
            .sort({ createdAt: -1 })
            .skip(skip)
            .limit(limit)
            .populate('user', 'username avatar'); 

        res.json({
            posts,
            currentPage: page,
            totalPages: Math.ceil(totalPosts / limit),
            totalPosts
        });

    } catch (error) {
        console.error('获取用户帖子列表失败:', error);
        res.status(500).json({ error: '获取用户帖子列表失败' });
    }
}


// 管理员更新帖子状态 (审核)
async function updatePostStatus(req, res) {
  const errors = validationResult(req);
  if (!errors.isEmpty()) {
    return res.status(400).json({ errors: errors.array() });
  }

  try {
    const postId = req.params.id;
    const { status } = req.body;

    const post = await Post.findById(postId);

    if (!post) {
      return res.status(404).json({ error: '帖子不存在' });
    }
    post.status = status;
    await post.save();
    res.json({ message: '帖子状态更新成功', post });

  } catch (error) {
    console.error('更新帖子状态失败:', error);
    res.status(500).json({ error: '更新帖子状态失败' });
  }
}

module.exports = {
  createPost,
  getPosts,
  getPostDetails,
  updatePost,
  deletePost,
  likePost,
  getPostInteractionStatus,
  getUserPosts,
  updatePostStatus 
};